// 全局配置文件
// 管理应用的全局状态、主题切换和通用设置

import { reactive, provide, inject } from 'vue';
import { themeConfig, themeUtils } from '../theme/themeConfig';
import { storage } from '../utils/storage';

// 全局配置状态
const globalConfigState = reactive({
  // 主题相关配置
  theme: {
    // 当前主题模式：light/dark/auto
    mode: 'light',
    // 是否应用高对比度
    highContrast: false,
    // 主色调配置
    primaryColor: themeConfig.colors.primary.base,
    // 字体大小缩放比例
    fontSizeScale: 1,
    // 是否应用动画效果
    animationsEnabled: true,
    // 是否跟随系统主题变化
    followSystem: false
  },
  
  // 布局相关配置
  layout: {
    // 导航栏配置
    navbar: {
      // 是否显示导航栏
      visible: true,
      // 导航栏高度
      height: themeConfig.layout.navbar.height,
      // 是否透明导航栏
      transparent: false,
      // 是否使用毛玻璃效果
      glassmorphism: false
    },
    // 底部栏配置
    tabbar: {
      // 是否显示底部栏
      visible: true,
      // 底部栏高度
      height: themeConfig.layout.tabbar.height,
      // 是否透明底部栏
      transparent: false,
      // 是否使用毛玻璃效果
      glassmorphism: false
    },
    // 内容区域配置
    content: {
      // 是否显示内容区边距
      padding: true,
      // 内容区最大宽度
      maxWidth: '100%'
    }
  },
  
  // 交互相关配置
  interaction: {
    // 点击反馈效果
    touchFeedback: {
      // 是否启用点击反馈
      enabled: true,
      // 反馈类型：ripple/scale/none
      type: 'ripple',
      // 反馈持续时间
      duration: 300
    },
    // 页面转场动画
    transitions: {
      // 是否启用页面转场动画
      enabled: true,
      // 转场动画类型
      type: 'slide',
      // 动画持续时间
      duration: 300
    },
    // 加载状态
    loading: {
      // 默认加载提示文字
      text: '加载中...',
      // 加载动画类型
      type: 'spinner',
      // 是否显示加载遮罩
      mask: true
    }
  },
  
  // 功能开关配置
  features: {
    // 离线模式
    offlineMode: {
      // 是否启用离线模式
      enabled: false,
      // 自动同步数据
      autoSync: true
    },
    // 数据缓存
    dataCache: {
      // 是否启用数据缓存
      enabled: true,
      // 缓存过期时间（分钟）
      expirationTime: 60
    },
    // 推送通知
    notifications: {
      // 是否启用推送通知
      enabled: true,
      // 学习提醒
      studyReminders: true,
      // 成就通知
      achievementNotifications: true,
      // 系统通知
      systemNotifications: true
    },
    // 语音功能
    voice: {
      // 是否启用语音朗读
      enabled: true,
      // 朗读速度
      speed: 1,
      // 默认语音
      voice: 'default'
    }
  },
  
  // 性能优化配置
  performance: {
    // 图片压缩
    imageCompression: {
      // 是否启用图片压缩
      enabled: true,
      // 压缩质量（0-1）
      quality: 0.8
    },
    // 预加载
    preloading: {
      // 是否启用预加载
      enabled: true,
      // 预加载页面数
      pages: 2
    },
    // 懒加载
    lazyLoading: {
      // 是否启用懒加载
      enabled: true,
      // 懒加载阈值
      threshold: 200
    }
  }
});

// 全局配置管理类
class GlobalConfigManager {
  constructor() {
    this.state = globalConfigState;
    this.listeners = new Map();
    this.initialize();
  }
  
  // 初始化配置
  initialize() {
    // 从本地存储加载配置
    this.loadConfigFromStorage();
    
    // 应用初始主题
    this.applyTheme();
    
    // 如果设置了跟随系统主题，添加监听器
    if (this.state.theme.followSystem) {
      this.setupSystemThemeListener();
    }
    
    // 应用性能优化设置
    this.applyPerformanceSettings();
  }
  
  // 从本地存储加载配置
  loadConfigFromStorage() {
    try {
      const savedConfig = storage.get('globalConfig');
      if (savedConfig && typeof savedConfig === 'object') {
        // 深度合并配置
        this.mergeConfig(savedConfig, this.state);
      }
    } catch (error) {
      console.error('加载配置失败:', error);
    }
  }
  
  // 保存配置到本地存储
  saveConfigToStorage() {
    try {
      storage.set('globalConfig', this.state, 365 * 24 * 60); // 保存一年
    } catch (error) {
      console.error('保存配置失败:', error);
    }
  }
  
  // 合并配置
  mergeConfig(source, target) {
    Object.keys(source).forEach(key => {
      if (target[key] && typeof target[key] === 'object' && !Array.isArray(target[key])) {
        this.mergeConfig(source[key], target[key]);
      } else {
        target[key] = source[key];
      }
    });
  }
  
  // 应用主题
  applyTheme() {
    const { mode, highContrast, primaryColor, fontSizeScale } = this.state.theme;
    
    // 应用主题模式
    if (mode === 'auto') {
      this.applySystemTheme();
    } else {
      this.applyManualTheme(mode);
    }
    
    // 应用高对比度模式
    if (highContrast) {
      document.documentElement.classList.add('high-contrast');
    } else {
      document.documentElement.classList.remove('high-contrast');
    }
    
    // 应用主色调
    this.applyPrimaryColor(primaryColor);
    
    // 应用字体大小缩放
    this.applyFontSizeScale(fontSizeScale);
    
    // 保存主题配置
    this.saveConfigToStorage();
    
    // 通知主题变更
    this.notifyThemeChange();
  }
  
  // 应用系统主题
  applySystemTheme() {
    const isDarkMode = window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches;
    this.applyManualTheme(isDarkMode ? 'dark' : 'light');
  }
  
  // 应用手动主题
  applyManualTheme(themeMode) {
    const root = document.documentElement;
    
    // 移除所有主题类
    root.classList.remove('theme-light', 'theme-dark');
    
    // 添加当前主题类
    root.classList.add(`theme-${themeMode}`);
    
    // 设置CSS变量
    const themeVars = themeMode === 'dark' ? this.getDarkThemeVars() : this.getLightThemeVars();
    this.setCssVariables(themeVars);
    
    // 更新主题模式状态
    this.state.theme.mode = themeMode;
  }
  
  // 设置系统主题监听器
  setupSystemThemeListener() {
    const mediaQuery = window.matchMedia('(prefers-color-scheme: dark)');
    
    // 初始应用
    this.applySystemTheme();
    
    // 添加变化监听器
    mediaQuery.addEventListener('change', () => {
      if (this.state.theme.followSystem && this.state.theme.mode === 'auto') {
        this.applySystemTheme();
      }
    });
  }
  
  // 应用主色调
  applyPrimaryColor(color) {
    this.setCssVariables({
      '--color-primary-base': color,
      '--color-primary-light': this.getColorShade(color, 1.2),
      '--color-primary-dark': this.getColorShade(color, 0.8)
    });
    
    // 更新状态
    this.state.theme.primaryColor = color;
  }
  
  // 应用字体大小缩放
  applyFontSizeScale(scale) {
    document.documentElement.style.fontSize = `${scale * 100}%`;
    this.state.theme.fontSizeScale = scale;
  }
  
  // 获取亮色主题变量
  getLightThemeVars() {
    return {
      '--color-background': themeConfig.colors.neutral.background.default,
      '--color-surface': themeConfig.colors.neutral.background.paper,
      '--color-text-primary': themeConfig.colors.neutral.text.primary,
      '--color-text-secondary': themeConfig.colors.neutral.text.secondary,
      '--color-border': themeConfig.colors.neutral.border.default,
      '--color-card': '#FFFFFF',
      '--color-card-hover': '#F5F7FA',
      '--color-card-active': '#EEEEEE',
      '--theme-brightness': 'light'
    };
  }
  
  // 获取暗色主题变量
  getDarkThemeVars() {
    return {
      '--color-background': '#121212',
      '--color-surface': '#1E1E1E',
      '--color-text-primary': '#FFFFFF',
      '--color-text-secondary': '#B0B0B0',
      '--color-border': '#333333',
      '--color-card': '#2D2D2D',
      '--color-card-hover': '#3D3D3D',
      '--color-card-active': '#4D4D4D',
      '--theme-brightness': 'dark'
    };
  }
  
  // 设置CSS变量
  setCssVariables(variables) {
    const root = document.documentElement;
    Object.entries(variables).forEach(([key, value]) => {
      root.style.setProperty(key, value);
    });
  }
  
  // 获取颜色阴影
  getColorShade(color, factor) {
    // 简单的颜色亮度调整
    return color.replace(/\d+\.?\d*/g, match => {
      const num = parseInt(match) * factor;
      return Math.round(Math.min(255, Math.max(0, num)));
    });
  }
  
  // 切换主题模式
  toggleThemeMode() {
    const modes = ['light', 'dark', 'auto'];
    const currentIndex = modes.indexOf(this.state.theme.mode);
    const nextIndex = (currentIndex + 1) % modes.length;
    
    this.setThemeMode(modes[nextIndex]);
    return modes[nextIndex];
  }
  
  // 设置主题模式
  setThemeMode(mode) {
    if (['light', 'dark', 'auto'].includes(mode)) {
      this.state.theme.mode = mode;
      this.applyTheme();
    }
  }
  
  // 设置跟随系统主题
  setFollowSystem(follow) {
    this.state.theme.followSystem = follow;
    if (follow) {
      this.setThemeMode('auto');
      this.setupSystemThemeListener();
    }
    this.applyTheme();
  }
  
  // 设置高对比度模式
  setHighContrast(highContrast) {
    this.state.theme.highContrast = highContrast;
    this.applyTheme();
  }
  
  // 设置主色调
  setPrimaryColor(color) {
    // 验证颜色格式
    if (/^#[0-9A-F]{6}$/i.test(color) || /^rgb\(\d+, \d+, \d+\)$/.test(color)) {
      this.applyPrimaryColor(color);
      this.applyTheme();
    }
  }
  
  // 设置字体大小缩放
  setFontSizeScale(scale) {
    // 限制在合理范围内
    const validScale = Math.max(0.8, Math.min(1.5, scale));
    this.applyFontSizeScale(validScale);
    this.saveConfigToStorage();
  }
  
  // 启用/禁用动画
  setAnimationsEnabled(enabled) {
    this.state.theme.animationsEnabled = enabled;
    if (enabled) {
      document.documentElement.classList.remove('no-animations');
    } else {
      document.documentElement.classList.add('no-animations');
    }
    this.saveConfigToStorage();
  }
  
  // 更新布局配置
  updateLayoutConfig(config) {
    Object.assign(this.state.layout, config);
    this.saveConfigToStorage();
    this.notifyLayoutChange();
  }
  
  // 更新交互配置
  updateInteractionConfig(config) {
    Object.assign(this.state.interaction, config);
    this.saveConfigToStorage();
  }
  
  // 更新功能开关配置
  updateFeaturesConfig(config) {
    Object.assign(this.state.features, config);
    this.saveConfigToStorage();
    this.notifyFeaturesChange();
  }
  
  // 更新性能优化配置
  updatePerformanceConfig(config) {
    Object.assign(this.state.performance, config);
    this.saveConfigToStorage();
    this.applyPerformanceSettings();
  }
  
  // 应用性能优化设置
  applyPerformanceSettings() {
    const { imageCompression, lazyLoading } = this.state.performance;
    
    // 设置图片压缩标志
    if (imageCompression.enabled) {
      document.documentElement.dataset.imageCompression = 'true';
      document.documentElement.dataset.imageQuality = imageCompression.quality;
    } else {
      document.documentElement.dataset.imageCompression = 'false';
    }
    
    // 设置懒加载标志
    if (lazyLoading.enabled) {
      document.documentElement.dataset.lazyLoading = 'true';
      document.documentElement.dataset.lazyThreshold = lazyLoading.threshold;
    } else {
      document.documentElement.dataset.lazyLoading = 'false';
    }
  }
  
  // 注册主题变更监听器
  onThemeChange(callback) {
    this.registerListener('themeChange', callback);
  }
  
  // 注册布局变更监听器
  onLayoutChange(callback) {
    this.registerListener('layoutChange', callback);
  }
  
  // 注册功能变更监听器
  onFeaturesChange(callback) {
    this.registerListener('featuresChange', callback);
  }
  
  // 注册监听器
  registerListener(event, callback) {
    if (!this.listeners.has(event)) {
      this.listeners.set(event, new Set());
    }
    this.listeners.get(event).add(callback);
    
    // 返回取消注册函数
    return () => {
      this.unregisterListener(event, callback);
    };
  }
  
  // 取消注册监听器
  unregisterListener(event, callback) {
    if (this.listeners.has(event)) {
      this.listeners.get(event).delete(callback);
    }
  }
  
  // 通知主题变更
  notifyThemeChange() {
    this.notifyListeners('themeChange', this.state.theme);
  }
  
  // 通知布局变更
  notifyLayoutChange() {
    this.notifyListeners('layoutChange', this.state.layout);
  }
  
  // 通知功能变更
  notifyFeaturesChange() {
    this.notifyListeners('featuresChange', this.state.features);
  }
  
  // 通知监听器
  notifyListeners(event, data) {
    if (this.listeners.has(event)) {
      this.listeners.get(event).forEach(callback => {
        try {
          callback(data);
        } catch (error) {
          console.error(`调用 ${event} 监听器失败:`, error);
        }
      });
    }
  }
  
  // 获取当前配置
  getConfig() {
    return { ...this.state };
  }
  
  // 重置配置到默认值
  resetConfig() {
    Object.assign(this.state, {
      theme: {
        mode: 'light',
        highContrast: false,
        primaryColor: themeConfig.colors.primary.base,
        fontSizeScale: 1,
        animationsEnabled: true,
        followSystem: false
      },
      layout: {
        navbar: {
          visible: true,
          height: themeConfig.layout.navbar.height,
          transparent: false,
          glassmorphism: false
        },
        tabbar: {
          visible: true,
          height: themeConfig.layout.tabbar.height,
          transparent: false,
          glassmorphism: false
        },
        content: {
          padding: true,
          maxWidth: '100%'
        }
      },
      interaction: {
        touchFeedback: {
          enabled: true,
          type: 'ripple',
          duration: 300
        },
        transitions: {
          enabled: true,
          type: 'slide',
          duration: 300
        },
        loading: {
          text: '加载中...',
          type: 'spinner',
          mask: true
        }
      },
      features: {
        offlineMode: {
          enabled: false,
          autoSync: true
        },
        dataCache: {
          enabled: true,
          expirationTime: 60
        },
        notifications: {
          enabled: true,
          studyReminders: true,
          achievementNotifications: true,
          systemNotifications: true
        },
        voice: {
          enabled: true,
          speed: 1,
          voice: 'default'
        }
      },
      performance: {
        imageCompression: {
          enabled: true,
          quality: 0.8
        },
        preloading: {
          enabled: true,
          pages: 2
        },
        lazyLoading: {
          enabled: true,
          threshold: 200
        }
      }
    });
    
    // 清除存储并应用新配置
    storage.remove('globalConfig');
    this.applyTheme();
    this.applyPerformanceSettings();
  }
}

// 创建全局配置管理器实例
const globalConfig = new GlobalConfigManager();

// 提供配置给Vue组件
export function provideGlobalConfig() {
  provide('globalConfig', globalConfig);
}

// 在组件中注入配置
export function useGlobalConfig() {
  const config = inject('globalConfig');
  if (!config) {
    throw new Error('全局配置未提供，请在应用根组件中调用 provideGlobalConfig');
  }
  return config;
}

// 导出全局配置实例
export { globalConfig };